R-Ladies + Lingwars: Taller de minería de textos con R

R-Ladies Madrid, Verónica García y Claudia Guirao, 17/10/2017

¿Quiénes somos?

• Verónica García, @yryaa
• Claudia Guirao, @claudiaguirao

RLadies y Data Scientists en Kernel Analytics

Código y datos en https://github.com/intiveda/rladies_textmining

Text Mining & NLP

Gran parte de los datos se encuentran no estructurados, es importante conocer técnicas que nos permitan obtener conclusiones a partir de los mensajes que generan nuestras organizaciones, clientes o usuarios.

Hoy aprenderemos algunas técnicas básicas para manipular cadenas de texto y aplicaremos técnicas de NLP a subtítulos para obtener algunas conclusiones.

Materiales y librerías

• Subtítulos temporadas de los Simpsons
• Librerías:
• stringr
• subtools
• tm
• tidytext
• tidyverse
• dplyr
• datatable
• ggplot2
• plotly(opcional)
• igraph
• ggraph
• worldcloud
• knit

Back2basics: Strings y expresiones regulares

Las cadenas o strings cumplen un papel importante en las tareas de ETL o preparación de los datos. Una de las librerías esenciales en la materia es string

Stringr es uno de los paquetes diseñados por Hadley Wickham para asistir en las tareas de manipulación de strings:

• se integra con pipes (%<%)
• sus funciones son consistentes y fáciles de interpretar

¿Qué son las cadenas de texto o strings?

• Las cadenas de texto se encuentran contenidas entre comillas "" (*usar la comilla simple ' para escapar la doble comilla)
• Pueden contener letras "a", números "1", simbolos "&" o todo lo anterior "1a&"
• Mientras que los números puede ser a la vez integers y characters, las letras y los s?mbolos no tienen significado como integer y se traducen en NA

as.integer(c("a", "&", "123"))

[1]  NA  NA 123

c(factor("a"), "b", "&",1)

[1] "1" "b" "&" "1"

Concatenar integers y characters, convierte automáticamente los integers en characters.

c(as.character(factor("a")), "b", "&",1)

[1] "a" "b" "&" "1"

Operaciones básicas

Importar la librería

# install.packages("stringr")
library(stringr)

Operadores

Muchas de estas funciones tienne su equivalente en R base, pueden ser más lentas/menos eficientes

• str_to_upper(string): convierte un string en mayúsculas
• str_to_lower(string): convierte un string en minúsculas
• str_to_title(string): capitaliza un string

temas <- c("Código", "Mujeres", "tecnología", "Informática", "estadística", "Women", "Coders", "Aprendizaje", "automático", "Análisis", "datos", "Visualización", "R-Ladies", "Social", "Coding", "R", "Ciencia", "Programming")

str_to_upper(temas)

 [1] "CÓDIGO"        "MUJERES"       "TECNOLOGÍA"    "INFORMÁTICA"   "ESTADÍSTICA"   "WOMEN"         "CODERS"       
 [8] "APRENDIZAJE"   "AUTOMÁTICO"    "ANÁLISIS"      "DATOS"         "VISUALIZACIÓN" "R-LADIES"      "SOCIAL"       
[15] "CODING"        "R"             "CIENCIA"       "PROGRAMMING"  

str_to_lower(temas)

 [1] "código"        "mujeres"       "tecnología"    "informática"   "estadística"   "women"         "coders"       
 [8] "aprendizaje"   "automático"    "análisis"      "datos"         "visualización" "r-ladies"      "social"       
[15] "coding"        "r"             "ciencia"       "programming"  

str_to_title(temas)

 [1] "Código"        "Mujeres"       "Tecnología"    "Informática"   "Estadística"   "Women"         "Coders"       
 [8] "Aprendizaje"   "Automático"    "Análisis"      "Datos"         "Visualización" "R-Ladies"      "Social"       
[15] "Coding"        "R"             "Ciencia"       "Programming"  

• str_c(string, sep = ""): junta varios string en uno solo, es el equivalente a paste(sep = "") o paste0()
• str_length(string): devuelve la longitud del string, es similar a la función nchar(). Convierte los factores en strings y conserva los NA’s

print(str_length('R-Ladies'))

[1] 8

print(str_length(NA))

[1] NA

• str_sub(string, start, end): subsetea un string o un vector de string especificando la posición inicial y la final, es el equivalente en R base a substr(). Por defecto finaliza en el último caracter.

print(temas[1:4])

[1] "Código"      "Mujeres"     "tecnología"  "Informática"

str_sub(string = temas[1:4], start=3)

[1] "digo"      "jeres"     "cnología"  "formática"

• str_dup(string, times): copia y pega un string un número determinado de veces

str_dup(string = temas[1:4], times = 3)

[1] "CódigoCódigoCódigo"                "MujeresMujeresMujeres"             "tecnologíatecnologíatecnología"   
[4] "InformáticaInformáticaInformática"

• str_trim(string, side = c("both", "left", "rigth")): elimina los espacios vacíos, por defecto toma el valor both. Mejor evitar gsub(" ", "", string)

• str_pad(string, width, side = c("left", "both", "right"), pad = " ")): añade a strings espacios en blanco para igualarlos en longitud, especialmente útil para añadir 0 a números.

Expresiones regulares

Las expresiones regulares ( regular expressions, regex, pattern matching) son un lenguaje usado para parsear y manipular texto. Se usan comúnmente para hacer operaciones de búsqueda y reemplazo y para validar si un texto está bien formado.

Expresiones comunes

• “a” = letra “a”
• “^a” = empieza con la letra “a”
• “a$” = finaliza con la letra “a”
• “[ ]” = contiene cualquier letra (o número) de las contenidas en los corchetes
• “[ - ]” = contiene cualquier letra (o número) dentro de un rango
• “[^ae]” = cualquier cosa excepto determinadas letras (o números)
• “{3}” = repite la expresión regular 3 veces

Las expresiones regulares son un mundo en si mismo, aquí tienes una pequeña chuleta : https://www.rstudio.com/wp-content/uploads/2016/09/RegExCheatsheet.pdf

rcosas = c("baseR", "R-Ladies", "Rmeetup", "Rmarkdown", "stringR")
str_detect(rcosas, pattern = "^R")

[1] FALSE  TRUE  TRUE  TRUE FALSE

rcosas[str_detect(rcosas, pattern = "^R")]

[1] "R-Ladies"  "Rmeetup"   "Rmarkdown"

rcosas[str_detect(rcosas, pattern = "R")]

[1] "baseR"     "R-Ladies"  "Rmeetup"   "Rmarkdown" "stringR"  

cleanR <- c("tidyverse", "tidyr","dplyr", "ggplot2", "tidytext", "purrr")
str_locate(cleanR, "tidy")

     start end
[1,]     1   4
[2,]     1   4
[3,]    NA  NA
[4,]    NA  NA
[5,]     1   4
[6,]    NA  NA

Otras funciones

• str_extract(string, pattern) o str_extract_all(): busca la palabra exacta (normalmente se utiliza con expresiones regulares concatenadas)
• str_match(string, pattern) o str_match_all(): es una función equivalente pero devuelve una matriz

str_match(c("12345678", "12587465", "dni desconocido"), pattern = "[1-9]{8}")

     [,1]      
[1,] "12345678"
[2,] "12587465"
[3,] NA        

str_match_all(c("12345678", "12587465", "dni desconocido"), pattern = "[1-9]{8}")

[[1]]
     [,1]      
[1,] "12345678"

[[2]]
     [,1]      
[1,] "12587465"

[[3]]
     [,1]

• str_replace(string, pattern, replacement): reemplaza la primera instancia, str_replace_all para reemplazarlas todas

str_replace(c("castanya", "otonyo", "veronyo", "anyo", "nyonyo"), pattern = "ny", replacement = "ñ")

[1] "castaña" "otoño"   "veroño"  "año"     "ñonyo"  

str_replace_all(c("castanya", "otonyo", "veronyo", "anyo", "nyonyo"), pattern = "ny", replacement = "ñ")

[1] "castaña" "otoño"   "veroño"  "año"     "ñoño"   

• str_split(string, pattern): separa una cadena en un vector, str_split_fixed(string, pattern, n) lo hace en un número n determinado de elementos

print(str_split("Eres muy chu chu chuli",pattern = " "))

[[1]]
[1] "Eres"  "muy"   "chu"   "chu"   "chuli"

print(length(str_split("Eres muy chu chu chuli",pattern = " ")[[1]]))

[1] 5

Analizando texto con R: los Simpsons fuente de sabiduría

Leer los subtitutos

La librería subtools permite leer archivos .str y .sub, así como organizar cada diálogo en un data frame. Los archivos han de estar organizados en directorios por temporadas y cada uno ha de estar nombrado como S01xE01 para que se parsee correctamente el número de temporada y de episodio.

Nos centraremos en las 9 primeras temporadas de los Simpsons. Si descargamos la puntuación y representamos gráficamente el promedio del score por temporada, se observa un claro descenso a partir de la 10. Por otro lado son las temporadas que mejor conocemos gracias a sus numerosas repeticiones :)

knitr::include_graphics("C:/Users/ClaudiaG/Documents/rladies/rladies_repo/rladies_textmining/images/ratings.png",dpi = 100)

A continuación leemos los subtítulos ( en inglés ) de las 9 primeras temporadas de los Simpsons.

library(subtools)
a <- read.subtitles.serie(dir = "C:/Users/ClaudiaG/Documents/rladies/rladies_repo/rladies_textmining/The Simpsons/")

Read: 9 seasons, 205 episodes

df <- subDataFrame(a)
df <- df[complete.cases(df), ]
str(df)

'data.frame':   58066 obs. of  8 variables:
 $ ID          : chr  "<U+FEFF>1" "2" "3" "4" ...
 $ Timecode.in : chr  "00:00:00.042" "00:00:08.759" "00:00:10.761" "00:00:15.557" ...
 $ Timecode.out: chr  "00:00:00.042" "00:00:10.677" "00:00:13.180" "00:00:17.851" ...
 $ Text        : chr  "23.976" "Ooh! Careful, Homer!" "There's no time. We're late." "O little town of Bethlehem" ...
 $ season      : chr  "season 1" "season 1" "season 1" "season 1" ...
 $ season_num  : num  1 1 1 1 1 1 1 1 1 1 ...
 $ episode_num : num  1 1 1 1 1 1 1 1 1 1 ...
 $ serie       : chr  "The Simpsons" "The Simpsons" "The Simpsons" "The Simpsons" ...

Primer análisis: tm

Una primera opción es emplear la librería tm para nuestro análisis. La función tm_map nos va a permitir preparar nuestor documento para el análisis:

• conformar un corpus (conjunto estructurado de textos / documentos )
• transformar en minúsculas nuestro texto
• eliminar los signos de puntuación
• eliminar los números
• eliminar las stopwords
• eliminar los espacios en blanco

library(tm)
c <- tmCorpus(a)
c <- tm_map(c, content_transformer(tolower))
c <- tm_map(c, removePunctuation)
c <- tm_map(c, removeNumbers)
c <- tm_map(c, removeWords, stopwords("english"))
c <- tm_map(c, stripWhitespace)
c

<<SimpleCorpus>>
Metadata:  corpus specific: 1, document level (indexed): 4
Content:  documents: 205

El segundo paso, una vez preparado nuestro corpus, será el de construir la matriz de términos documentos. Para simplificar el análisis cada temporada constituirá un documento. De esta forma obtenemos para cada término la frecuencia por temporada.

TDM <- TermDocumentMatrix(c)
TDM <- as.matrix(TDM)
vec.season <- c(rep(x = 1,13), rep(2, 22), rep(3,24), rep(4,22), rep(5,24), rep(6,25), rep(7,25),rep(8,25), rep(9,25)) #episodios por temp
TDM.season <- t(apply(TDM, 1, function(x) tapply(x, vec.season, sum)))
colnames(TDM.season) <- paste0("S_", unique(vec.season))
head(TDM.season)

           
Terms       S_1 S_2 S_3 S_4 S_5 S_6 S_7 S_8 S_9
  able        6   4   3   0   6   7   4   2   4
  aboard      1   1   2   2   2   2   2   1   1
  acts        1   1   1   0   0   1   0   0   1
  adult       1   3   2   0   3   3   1   1   1
  affecting   1   0   0   0   0   0   0   0   0
  afford      5   8   5   1   2   4   8   6   1

A continuación representamos en una nube de términos dichas frecuencias: el tamaño indica el número de repeticiones y el color la temporada en la que más repeticiones presenta. La posición del término respecto de la etiqueta de temporada indica también la frecuencia por temporada.

Text mining con tidytext

La librería tidytext nos permite realizar operaciones como tf (frecuencia de términos) o tf_idf (frecuencia de término - frecuencia inversa de documento) con mayor agilidad.

De nuevo vamos a preparar el nuestros diálogos para el análisis eliminado las stopwords.

library(tidytext)
library(tidyverse)
data(stop_words)
tidy_df <- df %>%
  unnest_tokens(word, Text) %>%
  dplyr::anti_join(stop_words)

Joining, by = "word"

Eliminamos además aquellas “palabras” constituidas exclusivamente por números y la palabra simpson.

library(data.table)
tidy_df <- as.data.table(tidy_df)
tidy_df <- tidy_df[is.na(as.numeric(word))]

NAs introduced by coercion

tidy_df <- tidy_df[word != 'simpson']

Con nuestro data set limpio podemos representar en un gráfico de barras la frecuencia de términos. Lo que haremos será:

• agrupar por temporada
• sumar el número de veces que aparece el término (count)
• tomar el top 10 por temporada
• representar en un barplot para cada temporada dicha frecuencia

library(ggplot2)
tidy_df %>% group_by(season) %>%
        count(word, sort = TRUE) %>%
        top_n(15) %>%
        ggplot(aes(reorder(word,n), n, fill = season)) +
        geom_col() +
        coord_flip() +
        facet_wrap(~season, scales = "free_y") +
        labs(x = NULL) +
        guides(fill = FALSE) +
        scale_fill_brewer(palette = "Set1")

Selecting by n

Ahora que disponemos de la frecuencia podemos analizar la evolución en sus apariciones / tramas de cada personaje: + calculamos la frecuencia para todos los términos, no solo el top 15 + creamos dos listas, la familia Simpson y otros personajes relevantes de la trama + representamos ambas series series temporales

También podemos obtener y representar los bigramas (conjunto de 2 términos) y sus frecuencias. Se representan en forma de grafo los más comunes (aquellos que aparecen al menos 7 veces en una misma temporada)

También podemos realizar tf_idf sobre nuestro corpus para localizar las palabras más relevantes, en general y por temporada

tf_idf_df %>% 
  top_n(20) %>%
  ggplot(aes(word, tf_idf, fill = season)) +
  geom_col() +
  labs(x = NULL, y = "tf-idf") +
  coord_flip()

Selecting by tf_idf

tf_idf_df %>% 
  group_by(season) %>% 
  top_n(8) %>% 
  ungroup %>%
  ggplot(aes(reorder(word, tf_idf), tf_idf, fill = season)) +
  geom_col(show.legend = FALSE) +
  labs(x = NULL, y = "tf-idf") +
  facet_wrap(~season, ncol = 2, scales = "free") +
  coord_flip()

Selecting by tf_idf

Anexos y otra információn útil

• Subtools: http://www.pieceofk.fr/?p=437
• Stringr and Regex: https://rstudio-pubs-static.s3.amazonaws.com/180610_d3764c43f1e54692b7e84d21ec94772a.html
• Analisis Rick&Morty: http://tamaszilagyi.com/blog/a-tidy-text-analysis-of-rick-and-morty/
• Ggplot cheatsheet: https://www.rstudio.com/wp-content/uploads/2015/03/ggplot2-cheatsheet.pdf
• Plotly cheatsheet: https://images.plot.ly/plotly-documentation/images/r_cheat_sheet.pdf